// background.js
// AI记忆助手 - 滚动摘要
// 核心功能：管理会话状态、与后端通信、缓存历史消息数

console.log('[background] 服务启动...');

// 🧠 全局缓存：session_id → history_count
// 生产环境可用 chrome.storage.local 持久化
const sessionCache = new Map();

// 🌐 后端地址（开发环境）
const API_BASE = 'http://localhost:5000';

// 🛠️ 封装 fetch 请求，带超时和错误处理
async function request(url, options = {}) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10秒超时

    try {
        const response = await fetch(url, {
            ...options,
            signal: controller.signal,
            headers: {
                'Content-Type': 'application/json',
                'Accept': 'application/json',
                ...options.headers
            }
        });

        clearTimeout(timeoutId);

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        return await response.json();
    } catch (error) {
        clearTimeout(timeoutId);
        if (error.name === 'AbortError') {
            console.warn('[background] 请求超时:', url);
            throw new Error('请求超时');
        }
        console.error('[background] 请求失败:', error.message);
        throw error;
    }
}

// 🔁 获取历史消息数量（带缓存）
async function getHistoryCount(sessionId) {
    // 1. 先查缓存
    if (sessionCache.has(sessionId)) {
        console.log(`🎯 [background] 缓存命中: session=${sessionId}`);
        return sessionCache.get(sessionId);
    }

    // 2. 缓存未命中 → 请求后端
    try {
        console.log(`📡 [background] 请求历史消息数: session=${sessionId}`);
        const data = await request(`${API_BASE}/api/session/history`, {
            method: 'POST',
            body: JSON.stringify({ session_id: sessionId })
        });

        const historyCount = data.history_count || 0;
        sessionCache.set(sessionId, historyCount);

        console.log(`✅ [background] 获取成功: historyCount=${historyCount}`);
        return historyCount;
    } catch (error) {
        console.error(`❌ [background] 获取历史消息数失败:`, error.message);
        // 降级：返回 0，避免阻塞前端
        return 0;
    }
}


// 📤 上报新消息到后端 - 修复版
async function reportMessages(sessionId, current_total, message_type, new_messages) {
    try {
        console.log(`📤 [background] 上报消息: session=${sessionId}, total=${current_total}, 新增=${new_messages.length}，消息类型：${message_type}`);
        
        const data = await request(`${API_BASE}/api/report-message`, {
            method: 'POST',
            body: JSON.stringify({
                session_id: sessionId,
                current_total,
                message_type,
                new_messages
            })
        });

        console.log(`✅ [background] 上报成功:`, data);
        
        // ✅ 关键修复：返回 API 响应数据
        return data;
        
    } catch (error) {
        console.error(`❌ [background] 上报失败:`, error.message);
        throw error;
    }
}

// 📬 监听来自 content_script 的消息
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
    console.log(`📨 [background] 收到消息:`, request.type, request);

    // 🔹 获取历史消息数
    if (request.type === 'getHistoryCount') {
        getHistoryCount(request.sessionId)
            .then(count => sendResponse({ historyCount: count }))
            .catch(() => sendResponse({ historyCount: 0 }));
        return true; // 保持通道开放（异步响应）
    }

    // 🔹 上报新消息 - ✅ 修正：只有一个处理块
    if (request.type === 'reportMessages') {
        const { sessionId, current_total, message_type, new_messages } = request;
        
        reportMessages(sessionId, current_total, message_type, new_messages)
            .then(apiResponse => {
                // ✅ 转发后端 API 的完整响应
                console.log(`✅ [background] 转发API响应:`, apiResponse);
                sendResponse({
                    status: 'received',
                    sessionId: apiResponse.sessionId,
                    token_count: apiResponse.token_count,
                    total_uploaded: apiResponse.total_uploaded,
                    temp_token_count: apiResponse.temp_token_count,
                    summary_required: apiResponse.summary_required,
                    threshold: apiResponse.threshold
                });
            })
            .catch(error => {
                console.error(`❌ [background] API调用失败:`, error);
                // ✅ 错误时提供降级数据
                sendResponse({
                    status: 'error',
                    message: error.message,
                    sessionId: sessionId,
                    token_count: 0,
                    total_uploaded: current_total,
                    temp_token_count: 0,
                    summary_required: false
                });
            });
        
        return true; // ✅ 保持通道开放，等待异步响应
    }

    // 🔹 未知消息类型
    console.warn('[background] 未知消息类型:', request.type);
    sendResponse({ error: 'unknown_command' });
    return false;
});

// 🧹 可选：定时清理缓存（每小时）
setInterval(() => {
    console.log(`🧹 [background] 缓存清理: 当前 ${sessionCache.size} 个会话`);
    // 可加入 LRU 策略或过期时间
}, 3600000);

console.log('[background] 已就绪 ✅');